OpenCL-Dump device info

Dump OpenCL device 信息,通过clGetPlatformIDs() query出platforms数量,通过clGetDeviceInfo() query 对应device的信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
// Error handling strategy for this sample is fairly simple -- just print
// a message and terminate the application if something goes wrong.
#define CHECK_ERRORS(ERR) \
if(ERR != CL_SUCCESS) \
{ \
cerr \
<< "OpenCL error with code " << ERR \
<< " happened in file " << __FILE__ \
<< " at line " << __LINE__ \
<< ". Exiting...\n"; \
exit(1); \
}
void dump_platform_opecl_infos() {
using namespace std;
cl_uint num_of_platforms = 0;
cl_int err = CL_SUCCESS;
err = clGetPlatformIDs(0, 0, &num_of_platforms);
CHECK_ERRORS(err);
cout << "Number of available platforms: " << num_of_platforms << endl;
cl_platform_id * platforms = new cl_platform_id[num_of_platforms];
//get IDs for all platforms.
err = clGetPlatformIDs(num_of_platforms, platforms, 0);
CHECK_ERRORS(err);
for (cl_uint i = 0; i < num_of_platforms; i++) {
size_t platform_name_length = 0;
err = clGetPlatformInfo(
platforms[i],
CL_PLATFORM_NAME,
0,
0,
&platform_name_length);
CHECK_ERRORS(err);
char * platform_name = new char[platform_name_length];
err = clGetPlatformInfo(
platforms[i],
CL_PLATFORM_NAME,
platform_name_length,
platform_name,
0);
CHECK_ERRORS(err);
cout << " [" << i << "] " << platform_name << endl;
delete [] platform_name;
}
cl_platform_id platform = platforms[0];
struct
{
cl_device_type type;
const char* name;
cl_uint count;
}
devices[] =
{
{ CL_DEVICE_TYPE_CPU, "CL_DEVICE_TYPE_CPU", 0 },
{ CL_DEVICE_TYPE_GPU, "CL_DEVICE_TYPE_GPU", 0 },
{ CL_DEVICE_TYPE_ACCELERATOR, "CL_DEVICE_TYPE_ACCELERATOR", 0 }
};
const int NUM_OF_DEVICE_TYPES = sizeof(devices)/sizeof(devices[0]);
cout << "Number of devices available for each type:\n";
for(int i = 0; i < NUM_OF_DEVICE_TYPES; ++i)
{
err = clGetDeviceIDs(
platform,
devices[i].type,
0,
0,
&devices[i].count
);
if(CL_DEVICE_NOT_FOUND == err)
{
// that's OK to fall here, because not all types of devices, which
// you query for may be available for a particular system
devices[i].count = 0;
err = CL_SUCCESS;
}
CHECK_ERRORS(err);
cout
<< " " << devices[i].name << ": "
<< devices[i].count << endl;
}
// -----------------------------------------------------------------------
// 6. Now get a piece of useful capabilities information for each device.
// Group information by device type
cout << "\n*** Detailed information for each device ***\n";
for(int type_index = 0; type_index < NUM_OF_DEVICE_TYPES; ++type_index)
{
cl_uint cur_num_of_devices = devices[type_index].count;
if(cur_num_of_devices == 0)
{
// there is no devices of this type; move to the next type
continue;
}
// Retrieve a list of device IDs with type selected by type_index
cl_device_id* devices_of_type = new cl_device_id[cur_num_of_devices];
err = clGetDeviceIDs(
platform,
devices[type_index].type,
cur_num_of_devices,
devices_of_type,
0
);
CHECK_ERRORS(err);
// Iterate over all devices of the current device type
for(
cl_uint device_index = 0;
device_index < cur_num_of_devices;
++device_index
)
{
cout
<< "\n"
<< devices[type_index].name
<< "[" << device_index << "]\n";
cl_device_id device = devices_of_type[device_index];
// To enumerate capabilities information, use two help
// macros: one to print string information and another one to
// print numeric information. Both these macros use clGetDeviceInfo
// to retrieve required caps, and defined below:
#define PRINT_TEXT_PROPERTY(NAME) \
{ \
/* When we query for string properties, first we */ \
/* need to get string length: */ \
size_t property_length = 0; \
err = clGetDeviceInfo( \
device, \
NAME, \
0, \
0, \
&property_length \
); \
CHECK_ERRORS(err); \
/* Then allocate buffer. No need to add 1 symbol */ \
/* to store terminating zero; OpenCL takes care */ \
/* about it: */ \
char* property_value = new char[property_length]; \
err = clGetDeviceInfo( \
device, \
NAME, \
property_length, \
property_value, \
0 \
); \
CHECK_ERRORS(err); \
cout \
<< " " << #NAME << ": " \
<< property_value << endl; \
delete [] property_value; \
}
#define PRINT_NUMERIC_PROPERTY(NAME, TYPE) \
{ \
TYPE property_value; \
size_t property_length = 0; \
err = clGetDeviceInfo( \
device, \
NAME, \
sizeof(property_value), \
&property_value, \
&property_length \
); \
assert(property_length == sizeof(property_value)); \
CHECK_ERRORS(err); \
cout \
<< " " << #NAME << ": " \
<< property_value << endl; \
}
PRINT_TEXT_PROPERTY(CL_DEVICE_NAME);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_AVAILABLE, cl_bool);
PRINT_TEXT_PROPERTY(CL_DEVICE_VENDOR);
PRINT_TEXT_PROPERTY(CL_DEVICE_PROFILE);
PRINT_TEXT_PROPERTY(CL_DEVICE_VERSION);
PRINT_TEXT_PROPERTY(CL_DRIVER_VERSION);
PRINT_TEXT_PROPERTY(CL_DEVICE_OPENCL_C_VERSION);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_MAX_COMPUTE_UNITS, cl_uint);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_MAX_CLOCK_FREQUENCY, cl_uint);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_MAX_WORK_GROUP_SIZE, size_t);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_ADDRESS_BITS, cl_uint);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_MEM_BASE_ADDR_ALIGN, cl_uint);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_MAX_MEM_ALLOC_SIZE, cl_ulong);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_GLOBAL_MEM_SIZE, cl_ulong);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, cl_ulong);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_GLOBAL_MEM_CACHE_SIZE, cl_ulong);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE, cl_uint);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_LOCAL_MEM_SIZE, cl_ulong);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_PROFILING_TIMER_RESOLUTION, size_t);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_IMAGE_SUPPORT, cl_bool);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_ERROR_CORRECTION_SUPPORT, cl_bool);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_HOST_UNIFIED_MEMORY, cl_bool);
PRINT_TEXT_PROPERTY(CL_DEVICE_EXTENSIONS);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, cl_uint);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, cl_uint);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT, cl_uint);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE, cl_uint);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, cl_uint);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, cl_uint);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT, cl_uint);
PRINT_NUMERIC_PROPERTY(CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE, cl_uint);
}
delete [] devices_of_type;
}
// -----------------------------------------------------------------------
// Final clean up
delete [] platforms;
}

输出结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
Number of available platforms: 1
[0] Apple
Number of devices available for each type:
CL_DEVICE_TYPE_CPU: 1
CL_DEVICE_TYPE_GPU: 1
CL_DEVICE_TYPE_ACCELERATOR: 0
*** Detailed information for each device ***
CL_DEVICE_TYPE_CPU[0]
CL_DEVICE_NAME: Intel(R) Core(TM) i5-6267U CPU @ 2.90GHz
CL_DEVICE_AVAILABLE: 1
CL_DEVICE_VENDOR: Intel
CL_DEVICE_PROFILE: FULL_PROFILE
CL_DEVICE_VERSION: OpenCL 1.2
CL_DRIVER_VERSION: 1.1
CL_DEVICE_OPENCL_C_VERSION: OpenCL C 1.2
CL_DEVICE_MAX_COMPUTE_UNITS: 4
CL_DEVICE_MAX_CLOCK_FREQUENCY: 2900
CL_DEVICE_MAX_WORK_GROUP_SIZE: 1024
CL_DEVICE_ADDRESS_BITS: 64
CL_DEVICE_MEM_BASE_ADDR_ALIGN: 1024
CL_DEVICE_MAX_MEM_ALLOC_SIZE: 4294967296
CL_DEVICE_GLOBAL_MEM_SIZE: 17179869184
CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE: 65536
CL_DEVICE_GLOBAL_MEM_CACHE_SIZE: 64
CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE: 4194304
CL_DEVICE_LOCAL_MEM_SIZE: 32768
CL_DEVICE_PROFILING_TIMER_RESOLUTION: 1
CL_DEVICE_IMAGE_SUPPORT: 1
CL_DEVICE_ERROR_CORRECTION_SUPPORT: 0
CL_DEVICE_HOST_UNIFIED_MEMORY: 1
CL_DEVICE_EXTENSIONS: cl_APPLE_SetMemObjectDestructor cl_APPLE_ContextLoggingFunctions cl_APPLE_clut cl_APPLE_query_kernel_names cl_APPLE_gl_sharing cl_khr_gl_event cl_khr_fp64 cl_khr_global_int32_base_atomics cl_khr_global_int32_extended_atomics cl_khr_local_int32_base_atomics cl_khr_local_int32_extended_atomics cl_khr_byte_addressable_store cl_khr_int64_base_atomics cl_khr_int64_extended_atomics cl_khr_3d_image_writes cl_khr_image2d_from_buffer cl_APPLE_fp64_basic_ops cl_APPLE_fixed_alpha_channel_orders cl_APPLE_biased_fixed_point_image_formats cl_APPLE_command_queue_priority
CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT: 4
CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG: 2
CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT: 4
CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE: 2
CL_DEVICE_NATIVE_VECTOR_WIDTH_INT: 4
CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG: 2
CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT: 4
CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE: 2
CL_DEVICE_TYPE_GPU[0]
CL_DEVICE_NAME: Intel(R) Iris(TM) Graphics 550
CL_DEVICE_AVAILABLE: 1
CL_DEVICE_VENDOR: Intel Inc.
CL_DEVICE_PROFILE: FULL_PROFILE
CL_DEVICE_VERSION: OpenCL 1.2
CL_DRIVER_VERSION: 1.2(May 3 2019 17:47:10)
CL_DEVICE_OPENCL_C_VERSION: OpenCL C 1.2
CL_DEVICE_MAX_COMPUTE_UNITS: 48
CL_DEVICE_MAX_CLOCK_FREQUENCY: 1050
CL_DEVICE_MAX_WORK_GROUP_SIZE: 256
CL_DEVICE_ADDRESS_BITS: 64
CL_DEVICE_MEM_BASE_ADDR_ALIGN: 1024
CL_DEVICE_MAX_MEM_ALLOC_SIZE: 402653184
CL_DEVICE_GLOBAL_MEM_SIZE: 1610612736
CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE: 65536
CL_DEVICE_GLOBAL_MEM_CACHE_SIZE: 0
CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE: 0
CL_DEVICE_LOCAL_MEM_SIZE: 65536
CL_DEVICE_PROFILING_TIMER_RESOLUTION: 80
CL_DEVICE_IMAGE_SUPPORT: 1
CL_DEVICE_ERROR_CORRECTION_SUPPORT: 0
CL_DEVICE_HOST_UNIFIED_MEMORY: 1
CL_DEVICE_EXTENSIONS: cl_APPLE_SetMemObjectDestructor cl_APPLE_ContextLoggingFunctions cl_APPLE_clut cl_APPLE_query_kernel_names cl_APPLE_gl_sharing cl_khr_gl_event cl_khr_global_int32_base_atomics cl_khr_global_int32_extended_atomics cl_khr_local_int32_base_atomics cl_khr_local_int32_extended_atomics cl_khr_byte_addressable_store cl_khr_image2d_from_buffer cl_khr_gl_depth_images cl_khr_depth_images cl_khr_3d_image_writes
CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT: 1
CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG: 1
CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT: 1
CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE: 0
CL_DEVICE_NATIVE_VECTOR_WIDTH_INT: 1
CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG: 1
CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT: 1
CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE: 0

参考Intel的示例项目